/**
 * 数组去重
 * @param {Array} arr - 输入数组
 * @returns {Array} 去重后的数组
 */
export function uniqueArray(arr) {
  if (!Array.isArray(arr)) {
    return [];
  }
  return [...new Set(arr)];
}

/**
 * 数组排序
 * @param {Array} arr - 输入数组
 * @param {string} key - 排序的键名（对象数组时使用）
 * @param {boolean} isAsc - 是否升序
 * @returns {Array} 排序后的数组
 */
export function sortArray(arr, key, isAsc = true) {
  if (!Array.isArray(arr)) {
    return [];
  }
  
  // 复制数组避免修改原数组
  const newArr = [...arr];
  
  newArr.sort((a, b) => {
    let valueA = a;
    let valueB = b;
    
    // 如果指定了key，说明是对象数组
    if (key) {
      valueA = a[key];
      valueB = b[key];
    }
    
    // 处理数字情况
    if (typeof valueA === 'number' && typeof valueB === 'number') {
      return isAsc ? valueA - valueB : valueB - valueA;
    }
    
    // 处理字符串情况
    const strA = String(valueA).toLowerCase();
    const strB = String(valueB).toLowerCase();
    
    if (strA < strB) {
      return isAsc ? -1 : 1;
    }
    if (strA > strB) {
      return isAsc ? 1 : -1;
    }
    return 0;
  });
  
  return newArr;
}

/**
 * 数组分组
 * @param {Array} arr - 输入数组
 * @param {Function|string} key - 分组依据的函数或键名
 * @returns {Object} 分组后的对象
 */
export function groupArray(arr, key) {
  if (!Array.isArray(arr)) {
    return {};
  }
  
  return arr.reduce((result, item) => {
    let groupKey;
    
    if (typeof key === 'function') {
      groupKey = key(item);
    } else if (typeof key === 'string') {
      groupKey = item[key];
    } else {
      groupKey = item;
    }
    
    if (!result[groupKey]) {
      result[groupKey] = [];
    }
    
    result[groupKey].push(item);
    return result;
  }, {});
}

/**
 * 数组扁平化
 * @param {Array} arr - 输入数组
 * @returns {Array} 扁平化后的数组
 */
export function flattenArray(arr) {
  if (!Array.isArray(arr)) {
    return [];
  }
  
  return arr.reduce((result, item) => {
    return result.concat(Array.isArray(item) ? flattenArray(item) : item);
  }, []);
}
